home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / comm / amigatcp.2 < prev    next >
Text File  |  1989-03-18  |  52KB  |  2,346 lines
  1. Path: xanth!ukma!tut.cis.ohio-state.edu!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i081:  amigatcp - tcp/ip for the amiga, Part02/06
  5. Message-ID: <12329@swan.ulowell.edu>
  6. Date: 17 Mar 89 23:16:44 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 2335
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: rminnich@super.org (Ronald G. Minnich)
  12. Posting-number: Volume 89, Issue 81
  13. Archive-name: comm/amigatcp.2
  14.  
  15. #    This is a shell archive.
  16. #    Remove everything above and including the cut line.
  17. #    Then run the rest of the file through sh.
  18. #----cut here-----cut here-----cut here-----cut here----#
  19. #!/bin/sh
  20. # shar:    Shell Archiver
  21. #    Run the following text with /bin/sh to create:
  22. #    icmp.c
  23. #    mbuf.c
  24. #    slip.c
  25. #    smtpcli.c
  26. #    tcpout.c
  27. #    tcpuser.c
  28. #    telnet.c
  29. # This archive created: Fri Mar 17 17:57:17 1989
  30. cat << \SHAR_EOF > icmp.c
  31. /* Internet Control Message Protocol */
  32.  
  33. #include "machdep.h"
  34. #include "internet.h"
  35. #include "timer.h"
  36. #include "ip.h"
  37. #include "icmp.h"
  38. #include "mbuf.h"
  39.  
  40. int (*echo_proc)();    /* Handler for Echo Reply messages */
  41.  
  42. struct icmp_errors icmp_errors;
  43. struct icmp_stats icmp_stats;
  44.  
  45. /* Process an incoming ICMP packet */
  46. void
  47. icmp_input(bp,protocol,source,dest,tos,length,rxbroadcast)
  48. struct mbuf *bp;    /* Pointer to ICMP message */
  49. char protocol;        /* Should always be ICMP_PTCL */
  50. int32 source;        /* Sender of ICMP message */
  51. int32 dest;        /* Us */
  52. char tos;        /* Type of Service */
  53. int16 length;        /* Length of ICMP message */
  54. char rxbroadcast;
  55. {
  56.  
  57.     struct icmp *icmph;    /* Pointer to ICMP message */
  58.     struct ip_header *iph;    /* Offending datagram header */
  59.     int16 type;        /* Type of ICMP message */
  60.     int16 ip_len;
  61.  
  62.     if(rxbroadcast){
  63.         /* Broadcast ICMP packets are to be IGNORED !! */
  64.         icmp_errors.bdcsts++;
  65.         free_p(bp);
  66.         return;
  67.     }
  68.     if(cksum(NULLHEADER,bp,length) != 0){
  69.         /* Bad ICMP checksum; discard */
  70.         icmp_errors.checksum++;
  71.         free_p(bp);
  72.         return;
  73.     }
  74.     /* If the message is fragmented, copy to a contiguous mbuf */
  75.     if(bp->next != NULLBUF){
  76.         struct mbuf *nbp;
  77.  
  78.         nbp = copy_p(bp,length);
  79.         free_p(bp);
  80.         if(nbp == NULLBUF){
  81.             icmp_errors.nospace++;
  82.             return;
  83.         }
  84.         bp = nbp;
  85.     }
  86.     icmph = (struct icmp *)bp->data;
  87.  
  88.     /* Process the message. Some messages are passed up to the protocol
  89.      * module for handling, others are handled here.
  90.      */
  91.     type = icmph->type & 0xff;
  92.     if(type < ICMP_TYPES)
  93.         icmp_stats.input[type]++;
  94.  
  95.     switch(type){
  96.     case TIME_EXCEED:    /* Time-to-live Exceeded */
  97.     case DEST_UNREACH:    /* Destination Unreachable */
  98.     case QUENCH:        /* Source Quench */
  99.         iph = (struct ip_header *)(icmph + 1);
  100.         ip_len = (iph->v_ihl & 0xf) * sizeof(int32);
  101.  
  102.         switch(iph->protocol){
  103.         case TCP_PTCL:
  104.             tcp_icmp(ntohl(iph->source),ntohl(iph->dest),
  105.                 icmph->type,icmph->code,(char *)iph + ip_len);
  106.             break;
  107.         }
  108.         break;
  109.     case ECHO:        /* Echo Request */
  110.         /* Change type to ECHO_REPLY, recompute checksum,
  111.          * and return datagram.
  112.          */
  113.         icmph->type = ECHO_REPLY;
  114.         icmph->checksum = 0;
  115.         icmph->checksum = cksum(NULLHEADER,bp,length);
  116.         icmp_stats.output[ECHO_REPLY]++;
  117.         ip_send(dest,source,ICMP_PTCL,tos,0,bp,length,0,0);
  118.         return;
  119.     case REDIRECT:        /* Redirect */
  120.     case PARAM_PROB:    /* Parameter Problem */
  121.         break;
  122.        case ECHO_REPLY:        /* Echo Reply */
  123.         if(echo_proc){
  124.             (*echo_proc)(ntohl(iph->source),ntohl(iph->dest),
  125.              icmph->type,icmph->code,(char *)iph + ip_len);
  126.         }
  127.         break;
  128.     case TIMESTAMP:        /* Timestamp */
  129.     case TIME_REPLY:    /* Timestamp Reply */
  130.     case INFO_RQST:        /* Information Request */
  131.     case INFO_REPLY:    /* Information Reply */
  132.         break;
  133.     }
  134.     free_p(bp);
  135. }
  136. /* Return an ICMP response to the sender of a datagram */
  137. icmp_output(bp,type,code,args)
  138. struct mbuf *bp;        /* Pointer to offending IP header + data */
  139. char type,code;            /* Codes to send */
  140. union icmp_args *args;
  141. {
  142.     struct ip_header *iph;    /* Offending IP header */
  143.     int16 ip_len;        /* Length of offending IP header */
  144.  
  145.     struct mbuf *reply;    /* Buffer with ICMP reply */
  146.     struct icmp *icmph;    /* ICMP protocol header */
  147.     struct mbuf *data;    /* Returned portion of offending packet */
  148.     int16 dlen;        /* Length of data portion of offending pkt */
  149.     int16 length;        /* Total length of reply */
  150.     extern int32 ip_addr;    /* Our IP address */
  151.  
  152.     if(type < ICMP_TYPES)
  153.         icmp_stats.output[type]++;
  154.  
  155.     iph = (struct ip_header *)bp->data;
  156.  
  157.     if(iph->protocol == ICMP_PTCL){
  158.         icmp_errors.noloop++;
  159.         return;    /* Never send an ICMP message about another ICMP message */
  160.     }
  161.     /* Compute amount of original datagram to return.
  162.      * We return the original IP header, and up to 8 bytes past that.
  163.      */
  164.     ip_len = (iph->v_ihl & 0xf) * sizeof(int32);
  165.     dlen = ntohs(iph->length);
  166.     if(dlen > ip_len + 8)
  167.         dlen = ip_len + 8;
  168.     length = sizeof(struct icmp) + dlen;
  169.  
  170.     /* Allocate ICMP header and fill in */
  171.     if((reply = alloc_mbuf(sizeof(struct icmp))) == NULLBUF){
  172.         /* No space; don't bother */
  173.         icmp_errors.nospace++;
  174.         return;
  175.     }
  176.     reply->cnt = sizeof(struct icmp);
  177.     icmph = (struct icmp *)reply->data;
  178.     icmph->type = type;
  179.     icmph->code = code;
  180.     if(args != (union icmp_args *)NULL)
  181.         icmph->args.unused = args->unused;    /* copies whole union */
  182.     else
  183.         icmph->args.unused = 0;
  184.  
  185.     /* Link in a copy of the beginning of the original datagram */
  186.     data = copy_p(bp,dlen);
  187.     reply->next = data;    /* Could be NULL if copy fails */
  188.  
  189.     /* Compute ICMP checksum and send */
  190.     icmph->checksum = 0;
  191.     icmph->checksum = cksum(NULLHEADER,reply,length);
  192.  
  193.     ip_send(ip_addr,ntohl(iph->source),ICMP_PTCL,iph->tos,0,reply,length,0,0);
  194. }
  195. #ifdef    TRACE
  196. /* ICMP message types */
  197. char *icmptypes[] = {
  198.     "Echo Reply",
  199.     NULLCHAR,
  200.     NULLCHAR,
  201.     "Unreachable",
  202.     "Source Quench",
  203.     "Redirect",
  204.     NULLCHAR,
  205.     NULLCHAR,
  206.     "Echo Request",
  207.     NULLCHAR,
  208.     NULLCHAR,
  209.     "Time Exceeded",
  210.     "Parameter Problem",
  211.     "Timestamp",
  212.     "Timestamp Reply",
  213.     "Information Request",
  214.     "Information Reply"
  215. };
  216.  
  217. /* ICMP unreachable messages */
  218. char *unreach[] = {
  219.     "Network",
  220.     "Host",
  221.     "Protocol",
  222.     "Port",
  223.     "Fragmentation",
  224.     "Source route"
  225. };
  226. /* ICMP Time exceeded messages */
  227. char *exceed[] = {
  228.     "Time-to-live",
  229.     "Fragment reassembly"
  230. };
  231.  
  232. /* ICMP redirect messages */
  233. char *redirect[] = {
  234.     "Network",
  235.     "Host",
  236.     "TOS & Network",
  237.     "TOS & Host"
  238. };
  239.  
  240. int
  241. doicmpstat(argc,argv)
  242. int argc;
  243. char *argv[];
  244. {
  245.     extern struct icmp_errors icmp_errors;
  246.     extern struct icmp_stats icmp_stats;
  247.     register int i;
  248.  
  249.     printf("chksum err %u no space %u icmp %u bdcsts %u\r\n",
  250.      icmp_errors.checksum,icmp_errors.nospace,icmp_errors.noloop,
  251.      icmp_errors.bdcsts);
  252.     printf("type  rcvd  sent\r\n");
  253.     for(i=0;i<ICMP_TYPES;i++){
  254.         if(icmp_stats.input[i] == 0 && icmp_stats.output[i] == 0)
  255.             continue;
  256.         printf("%-6u%-6u%-6u",i,icmp_stats.input[i],
  257.             icmp_stats.output[i]);
  258.         if(icmptypes[i] != NULLCHAR)
  259.             printf("  %s",icmptypes[i]);
  260.         printf("\r\n");
  261.     }
  262.     return 0;
  263. }
  264. /* Dump an ICMP header */
  265. void
  266. icmp_dump(bp,source,dest,check)
  267. struct mbuf *bp;
  268. int32 source,dest;
  269. int check;        /* If 0, bypass checksum verify */
  270. {
  271.     register struct icmp *icmp;
  272.     char *codemsg;
  273.     struct mbuf *ibp;
  274.     int i;
  275.     char tmpbuf;
  276.  
  277.     if(bp == NULLBUF)
  278.         return;
  279.     /* If packet isn't in a single buffer, make a temporary copy and
  280.      * note the fact so we free it later
  281.      */
  282.     if(bp->next != NULLBUF){
  283.         bp = copy_p(bp,len_mbuf(bp));
  284.         tmpbuf = 1;
  285.     } else
  286.         tmpbuf = 0;
  287.  
  288.     codemsg = NULLCHAR;
  289.     icmp = (struct icmp *)bp->data;
  290.     if(icmp->type <= 16 && icmptypes[icmp->type] != NULLCHAR)
  291.         printf("ICMP: %s",icmptypes[icmp->type]);
  292.     else
  293.         printf("ICMP: type %u",icmp->type);
  294.  
  295.     switch(icmp->type){
  296.     case DEST_UNREACH:
  297.         if(icmp->code <= 5)
  298.             codemsg = unreach[icmp->code];
  299.         break;
  300.     case REDIRECT:
  301.         if(icmp->code <= 3)
  302.             codemsg = redirect[icmp->code];
  303.         break;
  304.     case TIME_EXCEED:
  305.         if(icmp->code <= 1)
  306.             codemsg = exceed[icmp->code];
  307.         break;
  308.     }    
  309.     if(codemsg != NULLCHAR)
  310.         printf(" %s",codemsg);
  311.     else
  312.         printf(" code %u",icmp->code);
  313.  
  314.     /* Special case for parameter problem message */
  315.     if(icmp->type == PARAM_PROB)
  316.         printf(" pointer = 0x%x",icmp->args.pointer);
  317.  
  318.     if(check){
  319.         /* Verify checksum */
  320.         if((i = cksum(NULLHEADER,bp,len_mbuf(bp))) != 0)
  321.             printf(" CHECKSUM ERROR (%u)",i);
  322.     }
  323.     printf("\r\n");
  324.     /* Dump the offending IP header, if any */
  325.     switch(icmp->type){
  326.     case DEST_UNREACH:
  327.     case TIME_EXCEED:
  328.     case PARAM_PROB:
  329.     case QUENCH:
  330.     case REDIRECT:
  331.         printf("Returned ");
  332.         dup_p(&ibp,bp,sizeof(struct icmp),
  333.             len_mbuf(bp) - sizeof(struct icmp));
  334.         ip_dump(ibp);
  335.         free_p(ibp);
  336.     }
  337.     if(tmpbuf)
  338.         free_p(bp);
  339. }
  340. #endif
  341. SHAR_EOF
  342. cat << \SHAR_EOF > mbuf.c
  343. /* Primitive mbuf allocate/free routines */
  344.  
  345. #ifdef TRACE
  346. #include <stdio.h>
  347. #endif
  348.  
  349. #include "machdep.h"
  350. #include "mbuf.h"
  351.  
  352. /* Allocate mbuf with associated buffer of 'size' bytes */
  353. struct mbuf *
  354. alloc_mbuf(size)
  355. register int16 size;
  356. {
  357.     register struct mbuf *bp;
  358.     char *malloc();
  359.  
  360.     if((bp = (struct mbuf *)malloc((unsigned)(size + sizeof(struct mbuf)))) == NULLBUF)
  361.         return NULLBUF;
  362.     bp->next = bp->anext = NULLBUF;
  363.     if(size != 0){
  364.         bp->data = (char *)(bp + 1);
  365.     } else {
  366.         bp->data = NULLCHAR;
  367.     }
  368.     bp->cnt = 0;
  369.     return bp;
  370. }
  371.  
  372. /* Free all resources associated with mbuf
  373.  * Return pointer to next mbuf in packet chain
  374.  */
  375. struct mbuf *
  376. free_mbuf(bp)
  377. register struct mbuf *bp;
  378. {
  379.     register struct mbuf *bp1 = NULLBUF;
  380.  
  381.     if(bp != NULLBUF){
  382.         bp1 = bp->next;
  383.         free((char *)bp);
  384.     }
  385.     return bp1;
  386. }
  387.  
  388. /* Free packet (a chain of mbufs). Return pointer to next packet on queue,
  389.  * if any
  390.  */
  391. struct mbuf *
  392. free_p(bp)
  393. register struct mbuf *bp;
  394. {
  395.     struct mbuf *abp;
  396.  
  397.     if(bp == NULLBUF)
  398.         return NULLBUF;
  399.     abp = bp->anext;
  400.     while(bp != NULLBUF)
  401.         bp = free_mbuf(bp);
  402.     return abp;
  403. }        
  404. /* Free entire queue of packets (of mbufs) */
  405. free_q(q)
  406. struct mbuf **q;
  407. {
  408.     register struct mbuf *bp;
  409.  
  410.     while((bp = dequeue(q)) != NULLBUF)
  411.         free_p(bp);
  412. }
  413.  
  414. /* Count up the total number of bytes in an mbuf */
  415. int16
  416. len_mbuf(bp)
  417. register struct mbuf *bp;
  418. {
  419.     int cnt;
  420.  
  421.     cnt = 0;
  422.     while(bp != NULLBUF){
  423.         cnt += bp->cnt;
  424.         bp = bp->next;
  425.     }
  426.     return cnt;
  427. }
  428. /* Count up the number of packets in a queue */
  429. int16
  430. len_q(bp)
  431. register struct mbuf *bp;
  432. {
  433.     register int cnt;
  434.  
  435.     for(cnt=0;bp != NULLBUF;cnt++,bp = bp->anext)
  436.         ;
  437.     return cnt;
  438. }
  439. /* Duplicate/enqueue/dequeue operations based on mbufs */
  440.  
  441. /* Duplicate first 'cnt' bytes of packet starting at 'offset'.
  442.  * This is done without copying data; only the headers are duplicated,
  443.  * but without data segments of their own. The pointers are set up to
  444.  * share the data segments of the original copy. The return pointer is
  445.  * passed back through the first argument, and the return value is the
  446.  * number of bytes actually duplicated.
  447.  */
  448. int16
  449. dup_p(hp,bp,offset,cnt)
  450. struct mbuf **hp;
  451. register struct mbuf *bp;
  452. register int16 offset;
  453. register int16 cnt;
  454. {
  455.     register struct mbuf *cp;
  456.     int16 tot;
  457.  
  458.     if(cnt == 0 || bp == NULLBUF || hp == (struct mbuf **)NULL){
  459.         if(hp != (struct mbuf **)NULL)
  460.             *hp = NULLBUF;
  461.         return 0;
  462.     }
  463.     if((*hp = cp = alloc_mbuf(0)) == NULLBUF){
  464.         return 0;
  465.     }
  466.     /* Skip over leading mbufs that are smaller than the offset */
  467.     while(bp != NULLBUF && bp->cnt <= offset){
  468.         offset -= bp->cnt;
  469.         bp = bp->next;
  470.     }
  471.     if(bp == NULLBUF){
  472.         free_mbuf(cp);
  473.         *hp = NULLBUF;
  474.         return 0;    /* Offset was too big */
  475.     }
  476.     tot = 0;
  477.     for(;;){
  478.         cp->data = bp->data + offset;
  479.         cp->cnt = min(cnt,bp->cnt - offset);
  480.         offset = 0;
  481.         cnt -= cp->cnt;
  482.         tot += cp->cnt;
  483.         bp = bp->next;
  484.         if(cnt == 0 || bp == NULLBUF || (cp->next = alloc_mbuf(0)) == NULLBUF)
  485.             break;
  486.         cp = cp->next;
  487.     }
  488.     return tot;
  489. }
  490. /* Copy first 'cnt' bytes of packet into a new, single mbuf */
  491. struct mbuf *
  492. copy_p(bp,cnt)
  493. register struct mbuf *bp;
  494. register int16 cnt;
  495. {
  496.     register struct mbuf *cp;
  497.     register char *wp;
  498.     register int16 n;
  499.  
  500.     if(bp == NULLBUF || cnt == 0 || (cp = alloc_mbuf(cnt)) == NULLBUF)
  501.         return NULLBUF;
  502.     wp = cp->data;
  503.     while(cnt != 0 && bp != NULLBUF){
  504.         n = min(cnt,bp->cnt);
  505.         bcopy(bp->data,wp,n);
  506.         wp += n;
  507.         cp->cnt += n;
  508.         cnt -= n;
  509.         bp = bp->next;
  510.     }
  511.     return cp;
  512. }
  513. /* Copy and delete "cnt" bytes from beginning of packet. Return number of
  514.  * bytes actually pulled off
  515.  */
  516. int16
  517. pullup(bph,buf,cnt)
  518. struct mbuf **bph;
  519. char *buf;
  520. int16 cnt;
  521. {
  522.     register struct mbuf *bp;
  523.     int16 n,tot;
  524.  
  525.     tot = 0;
  526.     if(bph == (struct mbuf **)NULL)
  527.         return 0;
  528.     while(*bph != NULLBUF && cnt != 0){
  529.         bp = *bph;
  530.         n = min(cnt,bp->cnt);
  531.         if(buf != NULLCHAR){
  532.             bcopy(bp->data,buf,n);
  533.             buf += n;
  534.         }
  535.         tot += n;
  536.         cnt -= n;
  537.         bp->data += n;
  538.         bp->cnt -= n;        
  539.         if(bp->cnt == 0){
  540.             *bph = free_mbuf(bp);
  541.         }
  542.     }
  543.     return tot;
  544. }
  545. /* Append mbuf to end of mbuf chain */
  546. int16
  547. append(bph,bp)
  548. struct mbuf **bph;
  549. struct mbuf *bp;
  550. {
  551.     register struct mbuf *p;
  552.  
  553.     if(bph == (struct mbuf **)NULL || bp == NULLBUF)
  554.         return;
  555.     if(*bph == NULLBUF){
  556.         /* First one on chain */
  557.         *bph = bp;
  558.     } else {
  559.         for(p = *bph ; p->next != NULLBUF ; p = p->next)
  560.             ;
  561.         p->next = bp;
  562.     }
  563. }
  564. /* Append packet to end of packet queue */
  565. void
  566. enqueue(q,bp)
  567. struct mbuf **q;
  568. struct mbuf *bp;
  569. {
  570.     register struct mbuf *p;
  571.     char i_state;
  572.  
  573.     if(q == (struct mbuf **)NULL || bp == NULLBUF)
  574.         return;
  575.     i_state = disable();
  576.     if(*q == NULLBUF){
  577.         /* List is empty, stick at front */
  578.         *q = bp;
  579.     } else {
  580.         for(p = *q ; p->anext != NULLBUF ; p = p->anext)
  581.             ;
  582.         p->anext = bp;
  583.     }
  584.     restore(i_state);
  585. }
  586. /* Unlink a packet from the head of the queue */
  587. struct mbuf *
  588. dequeue(q)
  589. register struct mbuf **q;
  590. {
  591.     register struct mbuf *bp;
  592.     char i_state;
  593.  
  594.     if(q == (struct mbuf **)NULL)
  595.         return NULLBUF;
  596.     i_state = disable();
  597.     if((bp = *q) != NULLBUF){
  598.         *q = bp->anext;
  599.         bp->anext = NULLBUF;
  600.     }
  601.     restore(i_state);
  602.     return bp;
  603. }    
  604.  
  605. /* Copy user data into an mbuf */
  606. struct mbuf *
  607. qdata(data,cnt)
  608. char *data;
  609. int16 cnt;
  610. {
  611.     register struct mbuf *bp;
  612.  
  613.     if((bp = alloc_mbuf(cnt)) == NULLBUF)
  614.         return NULLBUF;
  615.     bcopy(data,bp->data,cnt);
  616.     bp->cnt = cnt;
  617.     return bp;
  618. }
  619. /* Copy mbuf data into user buffer */
  620. int16
  621. dqdata(bp,buf,cnt)
  622. struct mbuf *bp;
  623. char *buf;
  624. unsigned cnt;
  625. {
  626.     unsigned n,tot;
  627.     struct mbuf *bp1;
  628.  
  629.     if(buf == NULLCHAR)
  630.         return 0;
  631.     
  632.     tot = 0;
  633.     for(bp1 = bp;bp1 != NULLBUF; bp1 = bp1->next){
  634.         n = min(bp1->cnt,cnt);
  635.         bcopy(bp1->data,buf,n);
  636.         cnt -= n;
  637.         buf += n;
  638.         tot += n;
  639.     }
  640.     free_p(bp);
  641.     return tot;
  642. }
  643. #ifdef    TRACE
  644. /* Comment this out if your library already has this function */
  645. #define    isprint(c)    ((c) >= ' ' && (c) < 0x7f)        /* Assumes ASCII */
  646.  
  647. /* Dump an mbuf in hex */
  648. void
  649. hexdump(bp)
  650. struct mbuf *bp;
  651. {
  652.     register struct mbuf *tbp;
  653.     int16 n;
  654.     int16 address;
  655.     void fmtline();
  656.  
  657.     if(bp == NULLBUF)
  658.         return;
  659.     tbp = copy_p(bp,len_mbuf(bp));
  660.     address = 0;
  661.     while(tbp->cnt != 0){
  662.         n = min(tbp->cnt,16);
  663.         fmtline(address,tbp->data,n);
  664.         address += n;
  665.         tbp->data += n;
  666.         tbp->cnt -= n;
  667.     }
  668.     free_p(tbp);
  669.     fflush(stdout);
  670. }
  671. /* Dump an mbuf in ascii */
  672. void
  673. asciidump(bp)
  674. struct mbuf *bp;
  675. {
  676.     struct mbuf *tbp;
  677.     char c;
  678.     int16 tot;
  679.  
  680.     if(bp == NULLBUF)
  681.         return;
  682.     tbp = copy_p(bp,len_mbuf(bp));
  683.     tot = 0;
  684.     while(pullup(&tbp,&c,1) == 1){
  685.         if((tot % 64) == 0)
  686.             printf("%04x  ",tot);
  687.         if(isprint(c))
  688.             putchar(c);
  689.         else
  690.             putchar('.');
  691.         tot++;
  692.         if((tot % 64) == 0)
  693.             printf("\r\n");
  694.     }
  695.     if((tot % 64) != 0)
  696.         printf("\r\n");
  697.     free_p(tbp);
  698.     fflush(stdout);
  699. }
  700. /* Print a buffer up to 16 bytes long in formatted hex with ascii
  701.  * translation, e.g.,
  702.  * 0000: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f  0123456789:;<=>?
  703.  */
  704. void
  705. fmtline(addr,buf,len)
  706. int16 addr;
  707. char *buf;
  708. int16 len;
  709. {
  710.     char line[80];
  711.     char *aptr,*cptr;
  712.     int16 c;
  713.     void ctohex();
  714.  
  715.     for(cptr = line;cptr < &line[80];cptr++)
  716.         *cptr = ' ';
  717.     ctohex(line,(int16)hibyte(addr));
  718.     ctohex(line+2,(int16)lobyte(addr));
  719.     aptr = &line[6];
  720.     cptr = &line[55];
  721.     while(len-- != 0){
  722.         c = *buf++ & 0xff;
  723.         ctohex(aptr,c);
  724.         aptr += 3;
  725.         c &= 0x7f;
  726.         if(isprint(c)){
  727.             *cptr++ = c;
  728.         } else {
  729.             *cptr++ = '.';
  730.         }
  731.     }
  732.     *cptr++ = '\r';
  733.     *cptr++ = '\n';
  734. #ifdef    AMIGA
  735.     *cptr = '\0';
  736.     printf(line);
  737. #else
  738.     fwrite(line,1,(unsigned)(cptr-line),stdout);
  739. #endif
  740. }
  741. /* Convert byte to two ascii-hex characters */
  742. static
  743. void
  744. ctohex(buf,c)
  745. char *buf;
  746. int16 c;
  747. {
  748.     static char hex[] = "0123456789abcdef";
  749.  
  750.     buf[0] = hex[hinibble(c)];
  751.     buf[1] = hex[lonibble(c)];
  752. }
  753. #endif
  754. SHAR_EOF
  755. cat << \SHAR_EOF > slip.c
  756. /* Send and receive IP datagrams on serial lines. Compatible with SLIP
  757.  * under Berkeley Unix.
  758.  */
  759. #ifdef    TRACE
  760. #include <stdio.h>
  761. #endif
  762. #include "machdep.h"
  763. #ifdef    TRACE
  764. #include "trace.h"
  765. #endif
  766. #include "mbuf.h"
  767. #include "iface.h"
  768. #include "ax25.h"
  769. #include "slip.h"
  770. #ifdef    AMIGA
  771. #include "amiga.h"
  772. #else
  773. #include "pc.h"
  774. #endif
  775.  
  776. int slip_send();
  777. int doslip();
  778. int asy_output();
  779.  
  780. /* Slip level control structure */
  781. struct slip slip[ASY_MAX];
  782. unsigned nasy;
  783.  
  784. /* Send routine for point-to-point slip
  785.  * This is a trivial function since there is no slip link-level header
  786.  */
  787. int
  788. slip_send(bp,interface,gateway,precedence,delay,throughput,reliability)
  789. struct mbuf *bp;        /* Buffer to send */
  790. struct interface *interface;    /* Pointer to interface control block */
  791. int32 gateway;            /* Ignored (SLIP is point-to-point) */
  792. char precedence;
  793. char delay;
  794. char throughput;
  795. char reliability;
  796. {
  797.     /* Queue a frame on the slip output queue and start transmitter */
  798.  
  799.     if(interface == NULLIF){
  800.         free_p(bp);
  801.         return;
  802.     }
  803. #ifdef    TRACE
  804.     if(trace & TRACE_SLIP){
  805.         printf("%s sent:\r\n",interface->name);
  806.         if((trace & TRACE_HDR) > 2)
  807.             ip_dump(bp);
  808.         if(trace & TRACE_DUMP)
  809.             hexdump(bp);
  810.         if(trace & TRACE_ASCII)
  811.             asciidump(bp);
  812.         fflush(stdout);
  813.     }
  814. #endif
  815.     slipq(interface->dev,bp);
  816. }
  817. /* Encode a packet in slip framing, put on link output queue, and kick
  818.  * transmitter
  819.  */
  820. slipq(dev,bp)
  821. int16 dev;        /* Serial line number */
  822. struct mbuf *bp;    /* Buffer to be sent */
  823. {
  824.     register struct slip *sp;
  825.     struct mbuf *slip_encode();
  826.  
  827.     if((bp = slip_encode(bp)) == NULLBUF)
  828.         return;    
  829.  
  830.     sp = &slip[dev];
  831.     enqueue(&sp->sndq,bp);
  832.     sp->sndcnt++;
  833.     if(sp->tbp == NULLBUF)
  834.         asy_start(dev);
  835. }
  836. /* Start output, if possible, on asynch device dev */
  837. static
  838. asy_start(dev)
  839. int16 dev;
  840. {
  841.     register struct slip *sp;
  842.  
  843.     if(!stxrdy(dev))
  844.         return;        /* Transmitter not ready */
  845.  
  846.     sp = &slip[dev];
  847.     if(sp->tbp != NULLBUF){
  848.         /* transmission just completed */
  849.         free_p(sp->tbp);
  850.         sp->tbp = NULLBUF;
  851.     }
  852.     if(sp->sndq == NULLBUF)
  853.         return;    /* No work */
  854.  
  855.     sp->tbp = dequeue(&sp->sndq);
  856.     sp->sndcnt--;
  857.     asy_output(dev,sp->tbp->data,sp->tbp->cnt);
  858. }
  859. /* Encode a packet in SLIP format */
  860. static
  861. struct mbuf *
  862. slip_encode(bp)
  863. struct mbuf *bp;
  864. {
  865.     struct mbuf *lbp;    /* Mbuf containing line-ready packet */
  866.     register char *cp;
  867.     register int cnt;
  868.     char c;
  869.  
  870.     /* Allocate output mbuf that's twice as long as the packet.
  871.      * This is a worst-case guess (consider a packet full of FR_ENDs!)
  872.      */
  873.     lbp = alloc_mbuf(2*len_mbuf(bp) + 2);
  874.     if(lbp == NULLBUF){
  875.         /* No space; drop */
  876.         free_p(bp);
  877.         return NULLBUF;
  878.     }
  879.     cp = lbp->data;
  880.     cnt = 0;
  881.  
  882.     /* Flush out any line garbage */
  883.     *cp++ = FR_END;
  884.     cnt++;
  885.  
  886.     /* Copy input to output, escaping special characters */
  887.     while(pullup(&bp,&c,1) == 1){
  888.         switch(c & 0xff){
  889.         case FR_ESC:
  890.             *cp++ = FR_ESC;
  891.             *cp++ = T_FR_ESC;
  892.             cnt += 2;
  893.             break;
  894.         case FR_END:
  895.             *cp++ = FR_ESC;
  896.             *cp++ = T_FR_END;
  897.             cnt += 2;
  898.             break;
  899.         default:
  900.             *cp++ = c;
  901.             cnt++;
  902.         }
  903.     }
  904.     *cp++ = FR_END;
  905.     cnt++;
  906.     lbp->cnt = cnt;
  907.     return lbp;
  908. }
  909. /* Process incoming bytes in SLIP format
  910.  * When a buffer is complete, return it; otherwise NULLBUF
  911.  */
  912. static
  913. struct mbuf *
  914. slip_decode(dev,c)
  915. int dev;    /* Slip unit number */
  916. char c;        /* Incoming character */
  917. {
  918.     struct mbuf *bp,*nbp;
  919.     register struct slip *sp;
  920.  
  921.     sp = &slip[dev];
  922.     switch(c & 0xff){
  923.     case FR_END:
  924.         if(sp->rbp != NULLBUF){
  925.             /* Kick upstairs */
  926.             bp = sp->rbp;
  927.             sp->rbp = NULLBUF;
  928.             sp->rcnt = 0;
  929.             /* Copy into contiguous buffer, if necessary */
  930.             if(bp->next != NULLBUF){
  931.                 nbp = copy_p(bp,len_mbuf(bp));
  932.                 free_p(bp);
  933.                 bp = nbp;
  934.             }
  935.             return bp;
  936.         }
  937.         return NULLBUF;
  938.     case FR_ESC:
  939.         sp->escaped = 1;
  940.         return NULLBUF;
  941.     }
  942.     if(sp->escaped){
  943.         sp->escaped = 0;
  944.         switch(c & 0xff){
  945.         case T_FR_ESC:
  946.             c = FR_ESC;
  947.             break;
  948.         case T_FR_END:
  949.             c = FR_END;
  950.             break;
  951.         default:
  952.             sp->errors++;
  953.         }
  954.     }
  955.     if(sp->rcnt == SLIP_MTU){
  956.         /* Packet is too large, drop it and start over */
  957.         free_p(sp->rbp);
  958.         sp->rbp = NULLBUF;
  959.         sp->rcnt = 0;
  960.         return NULLBUF;
  961.     }
  962.     /* We reach here with a character for the buffer;
  963.      * make sure there's space for it
  964.      */
  965.     if(sp->rbp == NULLBUF){
  966.         /* Allocate first mbuf for new packet */
  967.         if((sp->rbp1 = sp->rbp = alloc_mbuf(SLIP_ALLOC)) == NULLBUF)
  968.             return NULLBUF; /* No memory, drop */
  969.         sp->rcp = sp->rbp->data;
  970.     } else if(sp->rbp1->cnt == SLIP_ALLOC){
  971.         /* Current mbuf is full; link in another */
  972.         if((sp->rbp1->next = alloc_mbuf(SLIP_ALLOC)) == NULLBUF){
  973.             /* No memory, drop whole thing */
  974.             free_p(sp->rbp);
  975.             sp->rbp = NULLBUF;
  976.             sp->rcnt = 0;
  977.             return NULLBUF;
  978.         }
  979.         sp->rbp1 = sp->rbp1->next;
  980.         sp->rcp = sp->rbp1->data;
  981.     }
  982.     /* Store the character, increment fragment and total
  983.      * byte counts
  984.      */
  985.     *sp->rcp++ = c;
  986.     sp->rbp1->cnt++;
  987.     sp->rcnt++;
  988.     return NULLBUF;
  989. }
  990. /* Process SLIP line I/O */
  991. int
  992. doslip(interface)
  993. struct interface *interface;
  994. {
  995.     char c;
  996.     struct mbuf *bp;
  997.     int16 dev;
  998.  
  999.     dev = interface->dev;
  1000.     /* Process any pending input */
  1001.     while(asy_recv(dev,&c,1) != 0)
  1002.         if((bp = slip_decode(dev,c)) != NULLBUF)
  1003.             (*slip[dev].recv)(interface,bp);
  1004.  
  1005.     /* Kick the transmitter if it's idle */
  1006.     if(stxrdy(dev))
  1007.         asy_start(dev);
  1008. }
  1009. /* Unwrap incoming SLIP packets -- trivial operation since there's no
  1010.  * link level header
  1011.  */
  1012. slip_recv(interface,bp)
  1013. struct interface *interface;
  1014. struct mbuf *bp;
  1015. {
  1016. #ifdef    TRACE
  1017.     if(trace & TRACE_SLIP){
  1018.         printf("%s recv:\r\n",interface->name);
  1019.         if((trace & TRACE_HDR) > 2)
  1020.             ip_dump(bp);
  1021.         if(trace & TRACE_DUMP)
  1022.             hexdump(bp);
  1023.         if(trace & TRACE_ASCII)
  1024.             asciidump(bp);
  1025.         fflush(stdout);
  1026.     }
  1027. #endif
  1028.     ip_route(bp,0);
  1029. } 
  1030. /* Attach a serial interface to the system
  1031.  * argv[0]: hardware type, must be "asy"
  1032.  * argv[1]: I/O address, e.g., "0x3f8"
  1033.  * argv[2]: vector, e.g., "4"
  1034.  * argv[3]: mode, may be:
  1035.  *        "slip" (point-to-point SLIP)
  1036.  *        "ax25" (AX.25 UI frame format in SLIP for raw TNC)
  1037.  * argv[4]: interface label, e.g., "sl0"
  1038.  * argv[5]: receiver ring buffer size in bytes
  1039.  * argv[6]: maximum transmission unit, bytes
  1040.  * argv[7]: interface speed, e.g, "9600"
  1041.  */
  1042. asy_attach(argc,argv)
  1043. int argc;
  1044. char *argv[];
  1045. {
  1046.     register struct interface *if_asy;
  1047.     extern struct interface *ifaces;
  1048.     int dev;
  1049.     char *malloc(), *calloc();
  1050.     int asy_init();
  1051.     int asy_send();
  1052.     int doslip();
  1053.     int asy_stop();
  1054.     int ax_send();
  1055.     int kiss_recv();
  1056.     int kiss_output();
  1057.  
  1058.     if(nasy >= ASY_MAX){
  1059.         printf("Too many asynch controllers\r\n");
  1060.         return -1;
  1061.     }
  1062.     dev = nasy++;
  1063.  
  1064.     /* Initialize hardware-level control structure */
  1065.     asy[dev].addr = htoi(argv[1]);
  1066.     asy[dev].vec = htoi(argv[2]);
  1067.  
  1068.     /* Create interface structure and fill in details */
  1069.     if_asy = (struct interface *)calloc(1, sizeof(struct interface));
  1070.  
  1071.     if_asy->name = malloc(strlen(argv[4])+1);
  1072.     strcpy(if_asy->name,argv[4]);
  1073.     if_asy->mtu = atoi(argv[6]);
  1074.     if_asy->dev = dev;
  1075.     if_asy->recv = doslip;
  1076.     if_asy->stop = asy_stop;
  1077.  
  1078.     if(strcmp(argv[3],"slip") == 0){
  1079.         if_asy->send = slip_send;
  1080.         if_asy->output = NULLFP;
  1081.         if_asy->flags = 0;
  1082.         slip[dev].recv = slip_recv;
  1083.     }
  1084.     else if(strcmp(argv[3],"ax25") == 0){
  1085.         if_asy->send = ax_send;
  1086.         if_asy->output = kiss_output;
  1087.         if_asy->flags = IF_BROADCAST;
  1088.         if(if_asy->hwaddr == NULLCHAR)
  1089.             if_asy->hwaddr = malloc(AXALEN);
  1090.         bcopy((char *)&mycall,if_asy->hwaddr,AXALEN);
  1091.         slip[dev].recv = kiss_recv;
  1092.     }
  1093.     else {
  1094.         printf("Mode %s unknown for interface %s\r\n",
  1095.             argv[3],argv[4]);
  1096.         free((char *)if_asy);
  1097.         return -1;
  1098.     }
  1099.     if_asy->next = ifaces;
  1100.     ifaces = if_asy;
  1101.     asy_init(dev,(unsigned)atoi(argv[5]));
  1102.     asy_speed(dev,atoi(argv[7]));
  1103. }
  1104. SHAR_EOF
  1105. cat << \SHAR_EOF > smtpcli.c
  1106. /* smtpcli.c
  1107.  *    Client routines for Simple Mail Transfer Protocol ala RFC821
  1108.  *    A.D. Barksdale Garbee II, aka Bdale, N3EUA
  1109.  *    Copyright 1986 Bdale Garbee, All Rights Reserved.
  1110.  *    Permission granted for non-commercial copying and use, provided
  1111.  *    this notice is retained.
  1112.  */
  1113.  
  1114. #include <stdio.h>
  1115. #include "machdep.h"
  1116. #include "netuser.h"
  1117. #include "mbuf.h"
  1118. #include "timer.h"
  1119. #include "tcp.h"
  1120. #include "smtp.h"
  1121.  
  1122. extern int16 lport;            /* local port placeholder */
  1123. int32 aton();
  1124. static void sendit();
  1125. static struct timer smtpcli_t;
  1126. char *index(),*rindex();
  1127.  
  1128. /* init routine called when program fired up */
  1129. smtpclinit()
  1130. {
  1131.     int dosmtptick();
  1132.  
  1133.     smtpcli_t.func = (void (*)())dosmtptick;/* what to call on timeout */
  1134.     smtpcli_t.arg = 0;            /* dummy value */
  1135.     smtpcli_t.start = SMTPCLITIME;        /* set timer duration */
  1136.     start_timer(&smtpcli_t);        /* and fire it up */
  1137. }
  1138.  
  1139. /* this is the routine that gets called every so often to do outgoing mail
  1140.    processing */
  1141. int
  1142. dosmtptick()
  1143. {
  1144.     char     lfilename[LINELEN],
  1145.         tmpstring[LINELEN],
  1146.         wfilename[13],
  1147.         *ptr;
  1148.     FILE *lfile;
  1149.     struct smtp_msg *mp;
  1150.     struct socket lsocket, fsocket;
  1151.     char *calloc(),*malloc();
  1152.     void smtp_rec(), smtp_cts(), smtp_state();
  1153.  
  1154. /*    printf("DOSMTPTICK() entered\n");    */
  1155.     lsocket.address = ip_addr;    /* our ip address */
  1156.     fsocket.port = SMTP_PORT;
  1157. /* if lock file exists in mqueue dir, return */
  1158.     sprintf(lfilename,"%s%s",MAILQDIR,"lockfile");
  1159.     if ((lfile = fopen(lfilename,"x")) == NULL)
  1160.         return;
  1161. /* get next work filename from mqueue directory */
  1162.     sprintf(tmpstring,"%s%s",MAILQDIR,"*.wrk");
  1163. #ifndef    AMIGA
  1164.     filedir(tmpstring,0,wfilename);
  1165. #endif
  1166.     if (wfilename[0] == '\0')
  1167.         return;    /* no work to be done */
  1168. /* if we have work, rebuild the exact (non-wild) filename */
  1169.     mp = (struct smtp_msg *)calloc(1,sizeof (struct smtp_msg));
  1170.     sprintf(tmpstring,"%s%s",MAILQDIR,wfilename);
  1171.     ptr = &tmpstring[0];
  1172.     mp->filename = malloc((unsigned)strlen(ptr)+1);
  1173.     strcpy(mp->filename,ptr);
  1174. /*    printf("work file name: %s\n",mp->filename);    /* debug only */
  1175.     mp->wfile = fopen(mp->filename,"r");
  1176. /*   get ip address, from stuff, to stuff */
  1177.     fgets(tmpstring,LINELEN,mp->wfile);    /* read target ip addr */
  1178. /*    printf("target ip addr: %s\n",tmpstring);    */
  1179.     fgets(mp->toaddr,LINELEN,mp->wfile);        /* who to */
  1180.     rip(mp->toaddr);
  1181. /*    printf("addressee: %s\n",mp->toaddr);        */
  1182.     fgets(mp->fromaddr,LINELEN,mp->wfile);        /* who from */
  1183.     rip(mp->fromaddr);
  1184. /*    printf("sender: %s\n",mp->fromaddr);        */
  1185.     fclose(mp->wfile);
  1186. /* set up the rest of the socket info from what we got */
  1187.     fsocket.address = aton(tmpstring);    /* destination ip address */
  1188.     lsocket.port = lport++;            /* next unused port */
  1189. /*   open smtp connection */
  1190.     mp->state = CLI_OPEN_STATE;        /* init state placeholder */
  1191. /*    printf("Opening TCP connection for SMTP client\n");    */
  1192.     mp->tcb = open_tcp(&lsocket,&fsocket,TCP_ACTIVE,1024,
  1193.             smtp_rec,smtp_cts,smtp_state,0,(int *)mp);
  1194.     mp->tcb->user = (int *)mp;        /* Upward pointer */
  1195.  
  1196. /*    printf("releasing lock\n");        */
  1197.     if (lfile != NULL) {            /* release lock */
  1198.         fclose(lfile);
  1199.         unlink(lfilename);
  1200.     }
  1201. }
  1202.  
  1203. /* replace terminating end of line marker(s) with null */
  1204. rip(s)
  1205. char *s;
  1206. {
  1207.     char *c;
  1208.  
  1209.     c=s;
  1210.     while (*c != '\0') {
  1211.         switch (*c) {
  1212.         case '\r':
  1213.         case '\n':
  1214.             *c='\0';
  1215.             break;
  1216.         default:
  1217.             c++;
  1218.             break;
  1219.         }
  1220.     }
  1221. }
  1222.  
  1223. /* this is the master state machine that handles a single SMTP transaction */
  1224. smtp_transaction(mp)
  1225. struct smtp_msg *mp;
  1226. {
  1227.     char tmpstring[LINELEN];    /* where we build command lines */
  1228.  
  1229. /*    printf("SMTP_TRANSACTION() called, state=%u\n",mp->state);    */
  1230.     if (affirmative(mp)) {
  1231.         switch(mp->state) {
  1232.         case CLI_OPEN_STATE:
  1233.             mp->state = CLI_MAIL_STATE;
  1234.             /* issue MAIL command */
  1235. /*            printf("FROMADDR = %s\n",mp->fromaddr);        */
  1236.             sprintf(tmpstring,"mail from:<%s>\r\n",mp->fromaddr);
  1237.             sendit(mp,tmpstring);
  1238.             break;            
  1239.         case CLI_MAIL_STATE:
  1240.             mp->state = CLI_RCPT_STATE;
  1241.             /* issue RCPT command */
  1242.             sprintf(tmpstring,"rcpt to:<%s>\r\n",mp->toaddr);
  1243.             sendit(mp,tmpstring);
  1244.             break;
  1245.         case CLI_RCPT_STATE:
  1246.             mp->state = CLI_SEND_STATE;
  1247.             /* open text file */
  1248.             strcpy(tmpstring,mp->filename);
  1249.             strcpy(index(tmpstring,'.'),".txt");
  1250. /*            printf("text filename: %s",tmpstring);        */
  1251.             mp->tfile = fopen(tmpstring,"r");
  1252.             /* issue DATA command */
  1253.             sprintf(tmpstring,"data\r\n");
  1254.             sendit(mp,tmpstring);
  1255.             break;
  1256.         case CLI_SEND_STATE:
  1257.             /* the transmitter upcall routine will advance the
  1258.                state pointer on end of file, so we do nada... */
  1259.             break;
  1260.         case CLI_UNLK_STATE:
  1261.             unlink(mp->filename);    /* unlink workfile */
  1262.             /* close and unlink the textfile */
  1263.             fclose(mp->tfile);
  1264.             strcpy(tmpstring,mp->filename);
  1265.             strcpy(index(tmpstring,'.'),".txt");
  1266.             unlink(tmpstring);
  1267.             mp->state = CLI_QUIT_STATE;
  1268.             /* issue a quit command */
  1269.             sprintf(tmpstring,"quit\r\n");
  1270.             sendit(mp,tmpstring);
  1271.             break;
  1272.         case CLI_QUIT_STATE:
  1273.             /* either start next transaction, or quit */
  1274.             close_tcp(mp->tcb);    /* close up connection */
  1275.             break;
  1276.         }
  1277.     } else {    /* if we get here, means we got a negative reply */
  1278.             /* for the moment, just let that hose us... */
  1279.         mp->state = CLI_QUIT_STATE;
  1280.         /* issue a quit command */
  1281.         sprintf(tmpstring,"quit\r\n");
  1282.         sendit(mp,tmpstring);
  1283.     }
  1284. }
  1285.  
  1286. /* return true if the passed string contains a positive response code */
  1287. affirmative(mp)
  1288. struct smtp_msg *mp;
  1289. {
  1290.     /* 2 is always good, 3 is ok if we've just sent 'data' command */
  1291.     if ((*mp->buf = '2') || 
  1292.            ((*mp->buf = '3') && (mp->state = CLI_DATA_STATE)))
  1293.         return 1;
  1294.     else     return 0;
  1295. }
  1296.  
  1297. /* smtp receiver upcall routine.  fires up the state machine to parse input */
  1298. static
  1299. void
  1300. smtp_rec(tcb,cnt)
  1301. struct tcb *tcb;
  1302. int16 cnt;
  1303. {
  1304.     register struct smtp_msg *mp;
  1305.     char *inet_ntoa(), c;
  1306.     struct mbuf *bp;
  1307.     /* may want a void line here for procedures used */
  1308.  
  1309. /*    printf("SMTP_REC called\n");        */
  1310.     mp = (struct smtp_msg *)tcb->user;    /* point to our struct */
  1311.     recv_tcp(tcb,&bp,cnt);    /* suck up chars from low level routine */
  1312.  
  1313.     /* Assemble input line in buffer, return if incomplete */
  1314.     while(pullup(&bp,&c,1) == 1) {
  1315.         switch(c) {
  1316.         case '\r':    /* strip cr's */
  1317.             continue;
  1318.         case '\n':    /* line is finished, go do it! */
  1319.             mp->buf[mp->cnt] = '\0';
  1320.             smtp_transaction(mp);
  1321.             break;
  1322.         default:    /* other chars get added to buffer */
  1323.             mp->buf[mp->cnt++] = c;
  1324.             break;
  1325.         }
  1326.     }
  1327. }
  1328.  
  1329. /* smtp transmitter ready upcall routine.  twiddles cts flag */
  1330. static 
  1331. void
  1332. smtp_cts(tcb,cnt)
  1333. struct tcb *tcb;
  1334. int16 cnt;
  1335. {
  1336.     register struct smtp_msg *mp;
  1337.     struct mbuf *bp;
  1338.     char tmpstring[LINELEN];
  1339.     char *cp;
  1340.     int c;
  1341.  
  1342. /*    printf("SMTP_CTS called\n");        */
  1343.     mp = (struct smtp_msg *)tcb->user;    /* point to our struct */
  1344.  
  1345.     /* don't do anything until/unless we're supposed to be sending */
  1346.     if(mp->state != CLI_SEND_STATE) return;
  1347.  
  1348.     if((bp = alloc_mbuf(cnt)) == NULLBUF){
  1349.         /* Hard to know what to do here */
  1350.         return;
  1351.     }
  1352.     cp = bp->data;
  1353.     while(cnt > 1 && (c = getc(mp->tfile)) != EOF){
  1354.         *cp++ = c;
  1355.         bp->cnt++;
  1356.         cnt--;
  1357.     }
  1358.     if(bp->cnt != 0)
  1359.         send_tcp(tcb,bp);
  1360.     else
  1361.         free_p(bp);
  1362.  
  1363.     if(cnt > 1){    /* EOF seen */
  1364.         sprintf(tmpstring,"\r\n.\r\n");
  1365.         sendit(mp,tmpstring);
  1366.         mp->state = CLI_UNLK_STATE;
  1367.     }
  1368. }
  1369.  
  1370. /* smtp state change upcall routine.  cans connection on error */
  1371. static
  1372. void
  1373. smtp_state(tcb,old,new)
  1374. struct tcb *tcb;
  1375. char old,new;
  1376. {
  1377.     struct smtp_msg *mp;
  1378.  
  1379. /*    printf("SMTP_STATE called, state=%u\n",new);    */
  1380.     mp = (struct smtp_msg *)tcb->user;
  1381.     switch(new) {
  1382.     case ESTABLISHED:
  1383.         mp->state = CLI_OPEN_STATE;    /* shouldn't be needed */
  1384.         break;
  1385.     case CLOSE_WAIT:
  1386.         close_tcp(tcb);            /* shut things down */
  1387.             /* may want to do something here to shut down
  1388.                the rest of the transaction? */
  1389.         break;
  1390.     case CLOSED:
  1391.         del_tcp(tcb);            /* hosed for good */
  1392.         if(mp->filename != NULLCHAR)
  1393.             free(mp->filename);
  1394.         free((char *)mp);
  1395.         break;
  1396.     }
  1397. }
  1398.  
  1399. /* Send message back to server */
  1400. static
  1401. void
  1402. sendit(mp,message)
  1403. struct smtp_msg *mp;
  1404. char *message;
  1405. {
  1406.     struct mbuf *bp,*qdata();
  1407.  
  1408. /*    printf("SENDIT called: %s",message);        */
  1409.     bp = qdata(message,(int16)strlen(message));
  1410.     send_tcp(mp->tcb,bp);
  1411. }
  1412. SHAR_EOF
  1413. cat << \SHAR_EOF > tcpout.c
  1414. #include "machdep.h"
  1415. #include "timer.h"
  1416. #include "mbuf.h"
  1417. #include "netuser.h"
  1418. #include "internet.h"
  1419. #include "tcp.h"
  1420.  
  1421. int16 tcp_mss = DEF_MSS; /* Maximum segment size to be sent with SYN */
  1422.  
  1423. /* Send a segment on the specified connection. One gets sent only
  1424.  * if there is data to be sent or if "force" is non zero
  1425.  */
  1426. void
  1427. tcp_output(tcb)
  1428. register struct tcb *tcb;
  1429. {
  1430.     struct pseudo_header ph;
  1431.     struct mbuf *hbp;
  1432.     int16 hsize;    /* Size of header */
  1433.     struct tcp_header *tcph;
  1434.     struct mss *mssp;
  1435.     int16 ssize;    /* Size of current segment being sent,
  1436.              * including SYN and FIN flags */
  1437.     int16 dsize;    /* Size of segment less SYN and FIN */
  1438.     int16 usable;    /* Usable window */
  1439.     int16 sent;    /* Sequence count (incl SYN/FIN) already in the pipe */
  1440.  
  1441.     if(tcb == NULLTCB)
  1442.         return;
  1443.  
  1444.     switch(tcb->state){
  1445.     case LISTEN:
  1446.     case CLOSED:
  1447.         return;    /* Don't send anything */
  1448.     }
  1449.     for(;;){
  1450.         sent = tcb->snd.ptr - tcb->snd.una;
  1451.  
  1452.         /* If this is a retransmission, send only the oldest segment
  1453.          * (first-only retransmission policy)
  1454.          */
  1455.         if(tcb->retry != 0 && sent != 0)
  1456.             break;
  1457.  
  1458.         /* There can only be one outstanding segment in this state
  1459.          * since the other end would reject any segment without SYN
  1460.          */
  1461.         if(tcb->state == SYN_SENT && sent != 0)
  1462.             break;
  1463.         if(tcb->snd.wnd == 0){
  1464.             /* Allow only one closed-window probe at a time */
  1465.             if(sent != 0)
  1466.                 break;
  1467.             /* Force a closed-window probe */
  1468.             usable = 1;
  1469.         } else {
  1470.             /* usable window = offered window - unacked bytes in transit */
  1471.             usable = tcb->snd.wnd - sent;
  1472.  
  1473.             /* John Nagle's "single outstanding segment" rule.
  1474.              * Allow only one segment in the pipeline unless there is enough
  1475.              * unsent data to form at least one maximum-sized segment.
  1476.              */
  1477.             if(sent != 0 && tcb->sndcnt - sent < tcb->mss){
  1478.                 usable = 0;
  1479.             }
  1480.             /* Silly window avoidance. Don't send anything if the usable window
  1481.              * is less than a quarter of the offered window.
  1482.              * This test comes into play only when the offered window is at
  1483.              * least 4 times the MSS; otherwise Nagle's test is sufficient
  1484.              * to prevent SWS.
  1485.               */
  1486.             else if(usable < tcb->snd.wnd/4){
  1487.                 usable = 0;
  1488.             }
  1489.         }
  1490.         /* Compute size of segment to send. This is either the usable
  1491.          * window, the mss, or the amount we have on hand, whichever is less.
  1492.          * (I don't like optimistic windows)
  1493.          */
  1494.         ssize = min(tcb->sndcnt - sent,usable);
  1495.         ssize = min(ssize,tcb->mss);
  1496.         dsize = ssize;
  1497.  
  1498.         if(ssize == 0 && tcb->force == 0)
  1499.             break;        /* No need to send anything */
  1500.  
  1501.         /* Determine size of TCP header and allocate mbuf.
  1502.          * If sending SYN, allow space for the MSS option
  1503.          */
  1504.         switch(tcb->state){
  1505.         case SYN_SENT:
  1506.         case SYN_RECEIVED:
  1507.             hsize = sizeof(struct tcp_header) + sizeof(struct mss);
  1508.             break;
  1509.         default:
  1510.             hsize = sizeof(struct tcp_header);
  1511.             break;
  1512.         }
  1513.         if((hbp = alloc_mbuf(hsize)) == NULLBUF)
  1514.             break;    /* No room to form a packet */
  1515.  
  1516.         tcb->force = 0;    /* Only one forced segment! */
  1517.         hbp->cnt = hsize;
  1518.  
  1519.         tcph = (struct tcp_header *)hbp->data;
  1520.         tcph->source = htons(tcb->conn.local.port);
  1521.         tcph->dest = htons(tcb->conn.remote.port);
  1522.         tcph->offset = hsize/sizeof(int32) << DSHIFT;
  1523.         tcph->flags = 0;
  1524.  
  1525.         /* Set the SYN and ACK flags according to the state we're in. It is
  1526.          * assumed that if this segment is associated with a state transition,
  1527.          * then the state change will already have been made. This allows
  1528.          * this routine to be called from a retransmission timeout with
  1529.          * force=1.
  1530.          * If SYN is being sent, adjust the dsize counter so we'll
  1531.          * try to get the right amount of data off the send queue.
  1532.          */
  1533.         switch(tcb->state){
  1534.         case SYN_SENT:
  1535.         case SYN_RECEIVED:
  1536.             if(tcb->snd.ptr == tcb->iss){
  1537.                 tcph->flags = SYN;
  1538.                 dsize--;
  1539.             }
  1540.             /* Also send MSS */
  1541.             mssp = (struct mss *)(tcph + 1);
  1542.             mssp->kind = MSS_KIND;
  1543.             mssp->length = MSS_LENGTH;
  1544.             mssp->mss = htons(tcp_mss);
  1545.         }
  1546.         switch(tcb->state){
  1547.         case SYN_RECEIVED:
  1548.         case ESTABLISHED:
  1549.         case CLOSE_WAIT:
  1550.         case FINWAIT2:
  1551.         case TIME_WAIT:
  1552.         case CLOSING:
  1553.         case FINWAIT1:
  1554.         case LAST_ACK:
  1555.             tcph->flags |= ACK;
  1556.             break;
  1557.         }
  1558.         tcph->seq = htonl(tcb->snd.ptr);
  1559.         tcph->ack = htonl(tcb->rcv.nxt);
  1560.         tcph->wnd = htons(tcb->rcv.wnd);
  1561.         tcph->checksum = 0;
  1562.         tcph->up = 0;
  1563.  
  1564.         /* Now try to extract some data from the send queue.
  1565.          * Since SYN and FIN occupy sequence space and are reflected
  1566.          * in sndcnt but don't actually sit in the send queue,
  1567.          * dup_p will return one less than dsize if a FIN needs to be sent.
  1568.          */
  1569.         if(dsize != 0){
  1570.             if(dup_p(&hbp->next,tcb->sndq,sent,dsize) != dsize){
  1571.                 /* We ran past the end of the send queue; send a FIN */
  1572.                 tcph->flags |= FIN;
  1573.                 dsize--;
  1574.             }
  1575.         }
  1576.         /* If the entire send queue will now be in the pipe, set the
  1577.          * push flag
  1578.          */
  1579.         if(dsize != 0 && sent + ssize == tcb->sndcnt)
  1580.             tcph->flags |= PSH;
  1581.  
  1582.         tcb->snd.ptr += ssize;
  1583.         /* If this is the first transmission of a range of sequence
  1584.          * numbers, record it so we'll accept acknowledgments
  1585.          * for it later
  1586.          */
  1587.         if(seq_gt(tcb->snd.ptr,tcb->snd.nxt))
  1588.             tcb->snd.nxt = tcb->snd.ptr;
  1589.         /* Fill in fields of pseudo IP header */
  1590.         ph.source = tcb->conn.local.address;
  1591.         ph.dest = tcb->conn.remote.address;
  1592.         ph.protocol = TCP_PTCL;
  1593.         ph.zero = 0;
  1594.         ph.length = hsize + dsize;
  1595.  
  1596.         /* Compute checksum over pseudo-header, TCP header and data,
  1597.          * and pass it off to IP
  1598.          */
  1599.         tcph->checksum = cksum(&ph,hbp,ph.length);
  1600.  
  1601.         /* If we're sending some data or flags, start retransmission
  1602.          * timer if it isn't already running.
  1603.          */
  1604.         if(ssize != 0){
  1605.             if(tcb->timer.state != TIMER_RUN){
  1606.                 /* Never initialize the timer with zero; it won't run! */
  1607.                 tcb->timer.start = max(tcb->timer.start,1);
  1608.                 start_timer(&tcb->timer);
  1609.             }
  1610.             /* If round trip timer isn't running, start it */
  1611.             if(seq_ge(tcb->snd.una,tcb->rttseq))
  1612.                 tcb->rttseq = tcb->snd.ptr;
  1613.         }
  1614.         ip_send(tcb->conn.local.address,tcb->conn.remote.address,
  1615.          TCP_PTCL,tcb->tos,0,hbp,ph.length,0,0);
  1616.     }
  1617. }
  1618. SHAR_EOF
  1619. cat << \SHAR_EOF > tcpuser.c
  1620. /* User calls to TCP */
  1621. #include "machdep.h"
  1622. #include "timer.h"
  1623. #include "mbuf.h"
  1624. #include "netuser.h"
  1625. #include "internet.h"
  1626. #include "ip.h"
  1627. #include "tcp.h"
  1628.  
  1629. int16 tcp_window = DEF_WND;
  1630.  
  1631. struct tcb *
  1632. open_tcp(lsocket,fsocket,active,window,r_upcall,t_upcall,s_upcall,tos,user)
  1633. struct socket *lsocket;    /* Local socket */
  1634. struct socket *fsocket;    /* Remote socket */
  1635. int active;        /* Active/passive */
  1636. int16 window;        /* Receive window (and send buffer) sizes */
  1637. void (*r_upcall)();    /* Function to call when data arrives */
  1638. void (*t_upcall)();    /* Function to call when ok to send more data */
  1639. void (*s_upcall)();    /* Function to call when connection state changes */
  1640. char tos;
  1641. int *user;        /* User linkage area */
  1642. {
  1643.     struct connection conn;
  1644.     register struct tcb *tcb;
  1645.     void send_syn();
  1646.  
  1647.     if(lsocket == NULLSOCK){
  1648.         net_error = INVALID;
  1649.         return NULLTCB;
  1650.     }
  1651.     conn.local.address = lsocket->address;
  1652.     conn.local.port = lsocket->port;
  1653.     if(fsocket != NULLSOCK){
  1654.         conn.remote.address = fsocket->address;
  1655.         conn.remote.port = fsocket->port;
  1656.     } else {
  1657.         conn.remote.address = 0;
  1658.         conn.remote.port = 0;
  1659.     }
  1660.     if((tcb = lookup_tcb(&conn)) == NULLTCB){
  1661.         if((tcb = create_tcb(&conn)) == NULLTCB){
  1662.             net_error = NO_SPACE;
  1663.             return NULLTCB;
  1664.         }
  1665.     } else if(tcb->state != LISTEN){
  1666.         net_error = CON_EXISTS;
  1667.         return NULLTCB;
  1668.     }
  1669.     tcb->user = user;
  1670.     if(window != 0)
  1671.         tcb->window = tcb->rcv.wnd = window;
  1672.     else
  1673.         tcb->window = tcb->rcv.wnd = tcp_window;
  1674.     tcb->r_upcall = r_upcall;
  1675.     tcb->t_upcall = t_upcall;
  1676.     tcb->s_upcall = s_upcall;
  1677.     tcb->tos = tos;
  1678.     if(!active){
  1679.         setstate(tcb,LISTEN);
  1680.         return tcb;
  1681.     }
  1682.     /* Send SYN, go into SYN_SENT state */
  1683.     send_syn(tcb);
  1684.     setstate(tcb,SYN_SENT);
  1685.     tcp_output(tcb);
  1686.     tcp_stat.conout++;
  1687.     return tcb;
  1688. }
  1689. /* User send routine */
  1690. int
  1691. send_tcp(tcb,bp)
  1692. register struct tcb *tcb;
  1693. struct mbuf *bp;
  1694. {
  1695.     int16 cnt;
  1696.  
  1697.     if(tcb == NULLTCB || bp == NULLBUF){
  1698.         free_p(bp);
  1699.         net_error = INVALID;
  1700.         return -1;
  1701.     }
  1702.     cnt = len_mbuf(bp);
  1703. #ifdef    TIGHT
  1704.     /* If this would overfill our send queue, reject it entirely */
  1705.     if(tcb->sndcnt + cnt > tcb->window){
  1706.         free_p(bp);
  1707.         net_error = WOULDBLK;
  1708.         return -1;
  1709.     }
  1710. #endif
  1711.     switch(tcb->state){
  1712.     case CLOSED:
  1713.         free_p(bp);
  1714.         net_error = NO_CONN;
  1715.         return -1;
  1716.     case LISTEN:    /* Change state from passive to active */
  1717.         send_syn(tcb);
  1718.         setstate(tcb,SYN_SENT);    /* Note fall-thru */
  1719.     case SYN_SENT:
  1720.     case SYN_RECEIVED:
  1721.     case ESTABLISHED:
  1722.     case CLOSE_WAIT:
  1723.         append(&tcb->sndq,bp);
  1724.         tcb->sndcnt += cnt;
  1725.         tcp_output(tcb);
  1726.         break;
  1727.     case FINWAIT1:
  1728.     case FINWAIT2:
  1729.     case CLOSING:
  1730.     case LAST_ACK:
  1731.     case TIME_WAIT:
  1732.         free_p(bp);
  1733.         net_error = CON_CLOS;
  1734.         return -1;
  1735.     }
  1736.     return cnt;
  1737. }
  1738. /* User receive routine */
  1739. int
  1740. recv_tcp(tcb,bp,cnt)
  1741. register struct tcb *tcb;
  1742. struct mbuf **bp;
  1743. int16 cnt;
  1744. {
  1745.     if(tcb == NULLTCB || bp == (struct mbuf **)NULL){
  1746.         net_error = INVALID;
  1747.         return -1;
  1748.     }
  1749.     /* cnt == 0 means "I want it all" */
  1750.     if(cnt == 0)
  1751.         cnt = tcb->rcvcnt;
  1752.     /* If there's something on the queue, just return it regardless
  1753.      * of the state we're in.
  1754.      */
  1755.     if(tcb->rcvcnt != 0){
  1756.         /* See if the user can take all of it */
  1757.         if(tcb->rcvcnt <= cnt){
  1758.             cnt = tcb->rcvcnt;
  1759.             *bp = tcb->rcvq;
  1760.             tcb->rcvq = NULLBUF;
  1761.         } else {
  1762.             if((*bp = alloc_mbuf(cnt)) == NULLBUF){
  1763.                 net_error = NO_SPACE;
  1764.                 return -1;
  1765.             }
  1766.             pullup(&tcb->rcvq,(*bp)->data,cnt);
  1767.             (*bp)->cnt = cnt;
  1768.         }
  1769.         tcb->rcvcnt -= cnt;
  1770.         tcb->rcv.wnd += cnt;
  1771.         /* Do a window update if it was closed */
  1772.         if(cnt == tcb->rcv.wnd){
  1773.             tcb->force = 1;
  1774.             tcp_output(tcb);
  1775.         }
  1776.         return cnt;
  1777.     } else {
  1778.         /* If there's nothing on the queue, our action depends on what state
  1779.          * we're in (i.e., whether or not we're expecting any more data).
  1780.          * If no more data is expected, then simply return 0; this is
  1781.          * interpreted as "end of file".
  1782.          */
  1783.         switch(tcb->state){
  1784.         case LISTEN:
  1785.         case SYN_SENT:
  1786.         case SYN_RECEIVED:
  1787.         case ESTABLISHED:
  1788.         case FINWAIT1:
  1789.         case FINWAIT2:
  1790.             *bp = NULLBUF;
  1791.             net_error = WOULDBLK;
  1792.             return -1;
  1793.         case CLOSED:
  1794.         case CLOSE_WAIT:
  1795.         case CLOSING:
  1796.         case LAST_ACK:
  1797.         case TIME_WAIT:
  1798.             *bp = NULLBUF;
  1799.             return 0;
  1800.         }
  1801.     }
  1802.     return 0;    /* Not reached, but lint doesn't know that */
  1803. }
  1804. /* This really means "I have no more data to send". It only closes the
  1805.  * connection in one direction, and we can continue to receive data
  1806.  * indefinitely.
  1807.  */
  1808. int
  1809. close_tcp(tcb)
  1810. register struct tcb *tcb;
  1811. {
  1812.     if(tcb == NULLTCB){
  1813.         net_error = INVALID;
  1814.         return -1;
  1815.     }
  1816.     switch(tcb->state){
  1817.     case LISTEN:
  1818.     case SYN_SENT:
  1819.         close_self(tcb,NORMAL);
  1820.         return 0;
  1821.     case SYN_RECEIVED:
  1822.     case ESTABLISHED:
  1823.         tcb->sndcnt++;
  1824.         tcb->snd.nxt++;
  1825.         setstate(tcb,FINWAIT1);
  1826.         tcp_output(tcb);
  1827.         return 0;
  1828.     case CLOSE_WAIT:
  1829.         tcb->sndcnt++;
  1830.         tcb->snd.nxt++;
  1831.         setstate(tcb,LAST_ACK);
  1832.         tcp_output(tcb);
  1833.         return 0;
  1834.     case FINWAIT1:
  1835.     case FINWAIT2:
  1836.     case CLOSING:
  1837.     case LAST_ACK:
  1838.     case TIME_WAIT:
  1839.         net_error = CON_CLOS;
  1840.         return -1;
  1841.     }
  1842.     return -1;    /* "Can't happen" */
  1843. }
  1844. /* Delete TCB, free resources. The user is not notified, even if the TCB is
  1845.  * not in the CLOSED state. This function should normally be called by the
  1846.  * user only in response to a state change upcall to CLOSED state.
  1847.  */
  1848. int
  1849. del_tcp(tcb)
  1850. register struct tcb *tcb;
  1851. {
  1852.     void unlink_tcb();
  1853.     struct reseq *rp,*rp1;
  1854.  
  1855.     if(tcb == NULLTCB){
  1856.         net_error = INVALID;
  1857.         return -1;
  1858.     }
  1859.     unlink_tcb(tcb);
  1860.     stop_timer(&tcb->timer);
  1861.     for(rp = tcb->reseq;rp != NULLRESEQ;rp = rp1){
  1862.         rp1 = rp->next;
  1863.         free_p(rp->bp);
  1864.         free((char *)rp);
  1865.     }
  1866.     tcb->reseq = NULLRESEQ;
  1867.     free_p(tcb->rcvq);
  1868.     free_p(tcb->sndq);
  1869.     free((char *)tcb);
  1870.     return 0;
  1871. }
  1872. /* Do printf on a tcp connection */
  1873. /*VARARGS*/
  1874. tprintf(tcb,message,arg1,arg2)
  1875. struct tcb *tcb;
  1876. char *message,*arg1,*arg2;
  1877. {
  1878.     struct mbuf *bp;
  1879.     int16 len;
  1880.     char *cp,*index();
  1881.  
  1882.     if(tcb == NULLTCB)
  1883.         return 0;
  1884.  
  1885.     len = strlen(message) + 10;    /* fudge factor */
  1886.     if((cp = index(message,'%')) != NULLCHAR){
  1887.         /* What a gross hack! */
  1888.         len += strlen(arg1);
  1889.         if((cp = index(cp+1,'%')) != NULLCHAR){
  1890.             /* I don't believe I'm writing this */
  1891.             len += strlen(arg2);
  1892.         }
  1893.     }
  1894.     bp = alloc_mbuf(len);
  1895.     len = sprintf(bp->data,message,arg1,arg2);
  1896.     bp->cnt = strlen(bp->data);
  1897.     send_tcp(tcb,bp);
  1898.     return len;
  1899. }
  1900. SHAR_EOF
  1901. cat << \SHAR_EOF > telnet.c
  1902. #include <stdio.h>
  1903. #include "machdep.h"
  1904. #include "mbuf.h"
  1905. #include "timer.h"
  1906. #include "internet.h"
  1907. #include "icmp.h"
  1908. #include "netuser.h"
  1909. #include "tcp.h"
  1910. #include "telnet.h"
  1911. #include "session.h"
  1912.  
  1913. extern char nospace[];
  1914. int refuse_echo = 0;
  1915. int unix_line_mode = 0;    /* if true turn <cr> to <nl> when in line mode */
  1916.  
  1917. #ifdef    DEBUG
  1918. char *t_options[] = {
  1919.     "Transmit Binary",
  1920.     "Echo",
  1921.     "",
  1922.     "Suppress Go Ahead",
  1923.     "",
  1924.     "Status",
  1925.     "Timing Mark"
  1926. };
  1927. #endif
  1928.  
  1929. /* Execute user telnet command */
  1930. int
  1931. dotelnet(argc,argv)
  1932. int argc;
  1933. char *argv[];
  1934. {
  1935.     void t_state(),rcv_char();
  1936.     char *inet_ntoa(),*calloc();
  1937.     int32 aton();
  1938.     int send_tel();
  1939.         int unix_send_tel();
  1940.     struct session *s,*newsession();
  1941.     struct telnet *tn;
  1942.     struct tcb *tcb;
  1943.     struct socket lsocket,fsocket;
  1944.  
  1945.  
  1946.     lsocket.address = ip_addr;
  1947.     lsocket.port = lport++;
  1948.     fsocket.address = aton(argv[1]);
  1949.     if(argc < 3)
  1950.         fsocket.port = TELNET_PORT;
  1951.     else
  1952.         fsocket.port = atoi(argv[2]);
  1953.  
  1954.     /* Allocate a session descriptor */
  1955.     if((s = newsession()) == NULLSESSION){
  1956.         printf("Too many sessions\r\n");
  1957.         return 1;
  1958.     }
  1959.     s->type = TELNET;
  1960.     if ((refuse_echo == 0) && (unix_line_mode != 0)) {
  1961.         s->parse = unix_send_tel;
  1962.     } else {
  1963.         s->parse = send_tel;
  1964.     }
  1965.     current = s;
  1966.  
  1967.     /* Create and initialize a Telnet protocol descriptor */
  1968.     if((tn = (struct telnet *)calloc(1,sizeof(struct telnet))) == NULLTN){
  1969.         printf(nospace);
  1970.         s->type = FREE;
  1971.         return 1;
  1972.     }
  1973.     tn->session = s;    /* Upward pointer */
  1974.     tn->state = TS_DATA;
  1975.     s->cb.telnet = tn;    /* Downward pointer */
  1976.  
  1977.     tcb = open_tcp(&lsocket,&fsocket,TCP_ACTIVE,0,
  1978.      rcv_char,NULLVFP,t_state,0,(int *)tn);
  1979.     if(tcb == NULLTCB || tcb->state == CLOSED){
  1980.         /* This is actually a bit dirty here. About the only time the
  1981.          * state will be closed here is if we tried to connect to
  1982.          * ourselves and got RST'ed.  If this is true then the close
  1983.          * upcall will already have freed the TCB and telnet block,
  1984.          * so we're looking at the TCB after it's back on the heap.
  1985.          */
  1986.         return 0;
  1987.     }
  1988.     tn->tcb = tcb;    /* Downward pointer */
  1989.     go();
  1990.     return 0;
  1991. }
  1992.  
  1993. /* Process typed characters */
  1994. int
  1995. unix_send_tel(buf,n)
  1996. char *buf;
  1997. int16 n;
  1998. {
  1999.     int i;
  2000.  
  2001.     for (i=0; (i<n) && (buf[i] != '\r'); i++)
  2002.         ;
  2003.     if (buf[i] == '\r') {
  2004.         buf[i] = '\n';
  2005.         n = i+1;
  2006.     }
  2007.     send_tel(buf,n);
  2008. }
  2009. int
  2010. send_tel(buf,n)
  2011. char *buf;
  2012. int16 n;
  2013. {
  2014.     struct mbuf *bp,*qdata();
  2015.     if(current == NULLSESSION || current->cb.telnet == NULLTN
  2016.      || current->cb.telnet->tcb == NULLTCB)
  2017.         return;
  2018.     bp = qdata(buf,n);
  2019.     send_tcp(current->cb.telnet->tcb,bp);
  2020. }
  2021.  
  2022. /* Process incoming TELNET characters */
  2023. int
  2024. tel_input(tn,bp)
  2025. register struct telnet *tn;
  2026. struct mbuf *bp;
  2027. {
  2028.     char c;
  2029.     int ci;
  2030.     void doopt(),dontopt(),willopt(),wontopt(),answer();
  2031. #ifdef    FAST    /* DON'T USE -- Aztec memchr() routine is broken */
  2032.     char *memchr();
  2033.  
  2034.     /* Optimization for very common special case -- no command chars */
  2035.     if(tn->state == TS_DATA){
  2036.         while(bp != NULLBUF && memchr(bp->data,IAC,bp->cnt) == NULLCHAR){
  2037.             fflush(stdout);
  2038.             write(1,bp->data,bp->cnt);
  2039.             bp = free_mbuf(bp);
  2040.         }
  2041.     }
  2042. #endif
  2043.     while(pullup(&bp,&c,1) == 1){
  2044.         ci = c & 0xff;
  2045.         switch(tn->state){
  2046.         case TS_DATA:
  2047.             if(ci == IAC){
  2048.                 tn->state = TS_IAC;
  2049.             } else {
  2050.                 if(!tn->remote[TN_TRANSMIT_BINARY])
  2051.                     c &= 0x7f;
  2052.                 putchar(c);
  2053.             }
  2054.             break;
  2055.         case TS_IAC:
  2056.             switch(ci){
  2057.             case WILL:
  2058.                 tn->state = TS_WILL;
  2059.                 break;
  2060.             case WONT:
  2061.                 tn->state = TS_WONT;
  2062.                 break;
  2063.             case DO:
  2064.                 tn->state = TS_DO;
  2065.                 break;
  2066.             case DONT:
  2067.                 tn->state = TS_DONT;
  2068.                 break;
  2069.             case IAC:
  2070.                 putchar(c);
  2071.                 tn->state = TS_DATA;
  2072.                 break;
  2073.             default:
  2074.                 tn->state = TS_DATA;
  2075.                 break;
  2076.             }
  2077.             break;
  2078.         case TS_WILL:
  2079.             willopt(tn,ci);
  2080.             tn->state = TS_DATA;
  2081.             break;
  2082.         case TS_WONT:
  2083.             wontopt(tn,ci);
  2084.             tn->state = TS_DATA;
  2085.             break;
  2086.         case TS_DO:
  2087.             doopt(tn,ci);
  2088.             tn->state = TS_DATA;
  2089.             break;
  2090.         case TS_DONT:
  2091.             dontopt(tn,ci);
  2092.             tn->state = TS_DATA;
  2093.             break;
  2094.         }
  2095.     }
  2096. }
  2097.  
  2098. /* Telnet receiver upcall routine */
  2099. void
  2100. rcv_char(tcb,cnt)
  2101. register struct tcb *tcb;
  2102. int16 cnt;
  2103. {
  2104.     struct mbuf *bp;
  2105.     struct telnet *tn;
  2106.  
  2107.     if((tn = (struct telnet *)tcb->user) == NULLTN){
  2108.         /* Unknown connection; ignore it */
  2109.         return;
  2110.     }
  2111.     /* Hold output if we're not the current session */
  2112.     if(mode != CONV_MODE || current == NULLSESSION || current->cb.telnet != tn)
  2113.         return;
  2114.  
  2115.     if(recv_tcp(tcb,&bp,cnt) > 0)
  2116.         tel_input(tn,bp);
  2117.  
  2118.     fflush(stdout);
  2119. }
  2120.  
  2121. /* State change upcall routine */
  2122. void
  2123. t_state(tcb,old,new)
  2124. register struct tcb *tcb;
  2125. char old,new;
  2126. {
  2127.     struct telnet *tn;
  2128.     char notify = 0;
  2129.     extern char *tcpstates[];
  2130.     extern char *reasons[];
  2131.     extern char *unreach[];
  2132.     extern char *exceed[];
  2133.  
  2134.     /* Can't add a check for unknown connection here, it would loop
  2135.      * on a close upcall! We're just careful later on.
  2136.      */
  2137.     tn = (struct telnet *)tcb->user;
  2138.  
  2139.     if(current != NULLSESSION && current->type == TELNET && current->cb.telnet == tn)
  2140.         notify = 1;
  2141.  
  2142.     switch(new){
  2143.     case CLOSE_WAIT:
  2144.         if(notify)
  2145.             printf("%s\r\n",tcpstates[new]);
  2146.         close_tcp(tcb);
  2147.         break;
  2148.     case CLOSED:    /* court adjourned */
  2149.         if(notify){
  2150.             printf("%s (%s",tcpstates[new],reasons[tcb->reason]);
  2151.             if(tcb->reason == NETWORK){
  2152.                 switch(tcb->type){
  2153.                 case DEST_UNREACH:
  2154.                     printf(": %s unreachable",unreach[tcb->code]);
  2155.                     break;
  2156.                 case TIME_EXCEED:
  2157.                     printf(": %s time exceeded",exceed[tcb->code]);
  2158.                     break;
  2159.                 }
  2160.             }
  2161.             printf(")\r\n");
  2162.             cmdmode();
  2163.         }
  2164.         del_tcp(tcb);
  2165.         if(tn != NULLTN)
  2166.             free_telnet(tn);
  2167.         break;
  2168.     default:
  2169.         if(notify)
  2170.             printf("%s\r\n",tcpstates[new]);
  2171.         break;
  2172.     }
  2173.     fflush(stdout);
  2174. }
  2175. /* Delete telnet structure */
  2176. static
  2177. free_telnet(tn)
  2178. struct telnet *tn;
  2179. {
  2180.     if(tn->session != NULLSESSION)
  2181.         freesession(tn->session);
  2182.  
  2183.     if(tn != NULLTN)
  2184.         free((char *)tn);
  2185. }
  2186.  
  2187. /* The guts of the actual Telnet protocol: negotiating options */
  2188. static
  2189. void
  2190. willopt(tn,opt)
  2191. struct telnet *tn;
  2192. int opt;
  2193. {
  2194.     int ack;
  2195.     void answer();
  2196.  
  2197. #ifdef    DEBUG
  2198.     printf("recv: will ");
  2199.     if(opt <= NOPTIONS)
  2200.         printf("%s\r\n",t_options[opt]);
  2201.     else
  2202.         printf("%u\r\n",opt);
  2203. #endif
  2204.     
  2205.     switch(opt){
  2206.     case TN_TRANSMIT_BINARY:
  2207.     case TN_ECHO:
  2208.     case TN_SUPPRESS_GA:
  2209.         if(tn->remote[opt] == 1)
  2210.             return;        /* Already set, ignore to prevent loop */
  2211.         if(opt == TN_ECHO){
  2212.             if(refuse_echo){
  2213.                 /* User doesn't want to accept */
  2214.                 ack = DONT;
  2215.                 break;
  2216.             } else
  2217.                 raw();        /* Put tty into raw mode */
  2218.         }
  2219.         tn->remote[opt] = 1;
  2220.         ack = DO;            
  2221.         break;
  2222.     default:
  2223.         ack = DONT;    /* We don't know what he's offering; refuse */
  2224.     }
  2225.     answer(tn,ack,opt);
  2226. }
  2227. static
  2228. void
  2229. wontopt(tn,opt)
  2230. struct telnet *tn;
  2231. int opt;
  2232. {
  2233.     void answer();
  2234.  
  2235. #ifdef    DEBUG
  2236.     printf("recv: wont ");
  2237.     if(opt <= NOPTIONS)
  2238.         printf("%s\r\n",t_options[opt]);
  2239.     else
  2240.         printf("%u\r\n",opt);
  2241. #endif
  2242.     if(opt <= NOPTIONS){
  2243.         if(tn->remote[opt] == 0)
  2244.             return;        /* Already clear, ignore to prevent loop */
  2245.         tn->remote[opt] = 0;
  2246.         if(opt == TN_ECHO)
  2247.             cooked();    /* Put tty into cooked mode */
  2248.     }
  2249.     answer(tn,DONT,opt);    /* Must always accept */
  2250. }
  2251. static
  2252. void
  2253. doopt(tn,opt)
  2254. struct telnet *tn;
  2255. int opt;
  2256. {
  2257.     void answer();
  2258.     int ack;
  2259.  
  2260. #ifdef    DEBUG
  2261.     printf("recv: do ");
  2262.     if(opt <= NOPTIONS)
  2263.         printf("%s\r\n",t_options[opt]);
  2264.     else
  2265.         printf("%u\r\n",opt);
  2266. #endif
  2267.     switch(opt){
  2268. #ifdef    FUTURE    /* Use when local options are implemented */
  2269.         if(tn->local[opt] == 1)
  2270.             return;        /* Already set, ignore to prevent loop */
  2271.         tn->local[opt] = 1;
  2272.         ack = WILL;
  2273.         break;
  2274. #endif
  2275.     default:
  2276.         ack = WONT;    /* Don't know what it is */
  2277.     }
  2278.     answer(tn,ack,opt);
  2279. }
  2280. static
  2281. void
  2282. dontopt(tn,opt)
  2283. struct telnet *tn;
  2284. int opt;
  2285. {
  2286.     void answer();
  2287.  
  2288. #ifdef    DEBUG
  2289.     printf("recv: dont ");
  2290.     if(opt <= NOPTIONS)
  2291.         printf("%s\r\n",t_options[opt]);
  2292.     else
  2293.         printf("%u\r\n",opt);
  2294. #endif
  2295.     if(opt <= NOPTIONS){
  2296.         if(tn->local[opt] == 0){
  2297.             /* Already clear, ignore to prevent loop */
  2298.             return;
  2299.         }
  2300.         tn->local[opt] = 0;
  2301.     }
  2302.     answer(tn,WONT,opt);
  2303. }
  2304. static
  2305. void
  2306. answer(tn,r1,r2)
  2307. struct telnet *tn;
  2308. int r1,r2;
  2309. {
  2310.     struct mbuf *bp,*qdata();
  2311.     char s[3];
  2312.  
  2313. #ifdef    DEBUG
  2314.     switch(r1){
  2315.     case WILL:
  2316.         printf("sent: will ");
  2317.         break;
  2318.     case WONT:
  2319.         printf("sent: wont ");
  2320.         break;
  2321.     case DO:
  2322.         printf("sent: do ");
  2323.         break;
  2324.     case DONT:
  2325.         printf("sent: dont ");
  2326.         break;
  2327.     }
  2328.     if(r2 <= 6)
  2329.         printf("%s\r\n",t_options[r2]);
  2330.     else
  2331.         printf("%u\r\n",r2);
  2332. #endif
  2333.  
  2334.     s[0] = IAC;
  2335.     s[1] = r1;
  2336.     s[2] = r2;
  2337.     bp = qdata(s,(int16)3);
  2338.     send_tcp(tn->tcb,bp);
  2339. }
  2340. SHAR_EOF
  2341. #    End of shell archive
  2342. exit 0
  2343. -- 
  2344. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  2345. Have five nice days.
  2346.